home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / thinkref / archive / THINKPascalUH2.1.sea / THINKPas Univ Hdr 2.1 / Interfaces / Memory.p < prev    next >
Text File  |  1995-09-12  |  15KB  |  567 lines
  1. { Converted with MPW2TPas Tuesday, September 12, 1995 7:38:09 PM }
  2. {
  3.      File:        Memory.p
  4.  
  5.      Contains:    Memory Manager Interfaces.
  6.  
  7.      Version:    Technology:    System 7.5
  8.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  9.  
  10.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  14.                  stack.  Include the file and version information (from above)
  15.                  in the problem description and send to:
  16.                      Internet:    apple.bugs@applelink.apple.com
  17.                      AppleLink:    APPLE.BUGS
  18.  
  19. }
  20.  
  21.  UNIT Memory;
  22.  INTERFACE
  23.  
  24.  
  25. {$IFC UNDEFINED __MEMORY__}
  26. {$SETC __MEMORY__ := 1}
  27.  
  28.   USES
  29.    ConditionalMacros, Types, MixedMode;
  30.  
  31. { $PUSH}
  32. { $ALIGN MAC68K}
  33. { $LibExport+}
  34.  
  35. CONST
  36.     maxSize                        = $800000;                        {Max data block size is 8 megabytes}
  37.     defaultPhysicalEntryCount    = 8;
  38. { values returned from the GetPageState function }
  39.     kPageInMemory                = 0;
  40.     kPageOnDisk                    = 1;
  41.     kNotPaged                    = 2;
  42.  
  43. { masks for Zone->heapType field }
  44.     k32BitHeap                    = 1;                            { valid in all Memory Managers }
  45.     kNewStyleHeap                = 2;                            { true if new Heap Manager is present }
  46.     kNewDebugHeap                = 4;                            { true if new Heap Manager is running in debug mode on this heap }
  47.  
  48. { size of a block in bytes }
  49.     
  50. TYPE
  51.     Size = LONGINT;
  52.  
  53.     GrowZoneProcPtr = ProcPtr;  { FUNCTION GrowZone(cbNeeded: Size): LONGINT; }
  54.     PurgeProcPtr = ProcPtr;  { PROCEDURE Purge(blockToPurge: Handle); }
  55.     {
  56.         UserFnProcPtr uses register based parameters on the 68k and cannot
  57.         be written in or called from a high-level language without the help of
  58.         mixed mode or assembly glue.
  59.  
  60.         In:
  61.          => *parameter      A0.L
  62.     }
  63.     UserFnProcPtr = Register68kProcPtr;  { register PROCEDURE UserFn(parameter: UNIV Ptr); }
  64.     GrowZoneUPP = UniversalProcPtr;
  65.     PurgeUPP = UniversalProcPtr;
  66.     UserFnUPP = UniversalProcPtr;
  67.  
  68.     THz = ^Zone;
  69.  
  70.     Zone = RECORD
  71.         bkLim:                    Ptr;
  72.         purgePtr:                Ptr;
  73.         hFstFree:                Ptr;
  74.         zcbFree:                LONGINT;
  75.         gzProc:                    GrowZoneUPP;
  76.         moreMast:                INTEGER;
  77.         flags:                    INTEGER;
  78.         cntRel:                    INTEGER;
  79.         maxRel:                    INTEGER;
  80.         cntNRel:                INTEGER;
  81.         heapType:                SInt8; { Byte }
  82.         unused:                    SInt8; { Byte }
  83.         cntEmpty:                INTEGER;
  84.         cntHandles:                INTEGER;
  85.         minCBFree:                LONGINT;
  86.         purgeProc:                PurgeUPP;
  87.         sparePtr:                Ptr;
  88.         allocPtr:                Ptr;
  89.         heapData:                INTEGER;
  90.     END;
  91.  
  92.     MemoryBlock = RECORD
  93.         address:                Ptr;
  94.         count:                    LONGINT;
  95.     END;
  96.  
  97.     LogicalToPhysicalTable = RECORD
  98.         logical:                MemoryBlock;
  99.         physical:                ARRAY [0..7] OF MemoryBlock;
  100.     END;
  101.  
  102.     PageState = INTEGER;
  103.  
  104.     StatusRegisterContents = INTEGER;
  105.  
  106. CONST
  107.     uppGrowZoneProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  108.     uppPurgeProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  109.     uppUserFnProcInfo = $00009802; { Register PROCEDURE (4 bytes in A0); }
  110.  
  111. FUNCTION NewGrowZoneProc(userRoutine: GrowZoneProcPtr): GrowZoneUPP;
  112.     {$IFC NOT GENERATINGCFM }
  113.     INLINE $2E9F;
  114.     {$ENDC}
  115.  
  116. FUNCTION NewPurgeProc(userRoutine: PurgeProcPtr): PurgeUPP;
  117.     {$IFC NOT GENERATINGCFM }
  118.     INLINE $2E9F;
  119.     {$ENDC}
  120.  
  121. FUNCTION NewUserFnProc(userRoutine: UserFnProcPtr): UserFnUPP;
  122.     {$IFC NOT GENERATINGCFM }
  123.     INLINE $2E9F;
  124.     {$ENDC}
  125.  
  126. FUNCTION CallGrowZoneProc(cbNeeded: Size; userRoutine: GrowZoneUPP): LONGINT;
  127.     {$IFC NOT GENERATINGCFM}
  128.     INLINE $205F, $4E90;
  129.     {$ENDC}
  130.  
  131. PROCEDURE CallPurgeProc(blockToPurge: Handle; userRoutine: PurgeUPP);
  132.     {$IFC NOT GENERATINGCFM}
  133.     INLINE $205F, $4E90;
  134.     {$ENDC}
  135.  
  136. PROCEDURE CallUserFnProc(parameter: UNIV Ptr; userRoutine: UserFnUPP);
  137.     {$IFC NOT GENERATINGCFM}
  138.     {To be implemented:  Glue to move parameters into registers.}
  139.     {$ENDC}
  140. FUNCTION GetApplLimit : Ptr;
  141.     {$IFC NOT CFMSYSTEMCALLS}
  142.     INLINE $2EB8, $0130;            { MOVE.l $0130,(SP) }
  143.     {$ENDC}
  144.  
  145. FUNCTION SystemZone : THz;
  146.     {$IFC NOT CFMSYSTEMCALLS}
  147.     INLINE $2EB8, $02A6;            { MOVE.l $02A6,(SP) }
  148.     {$ENDC}
  149.  
  150. FUNCTION ApplicationZone : THz;
  151.     {$IFC NOT CFMSYSTEMCALLS}
  152.     INLINE $2EB8, $02AA;            { MOVE.l $02AA,(SP) }
  153.     {$ENDC}
  154.  
  155. FUNCTION GZSaveHnd : Handle;
  156.     {$IFC NOT CFMSYSTEMCALLS}
  157.     INLINE $2EB8, $0328;            { MOVE.l $0328,(SP) }
  158.     {$ENDC}
  159.  
  160. FUNCTION TopMem : Ptr;
  161.     {$IFC NOT CFMSYSTEMCALLS}
  162.     INLINE $2EB8, $0108;            { MOVE.l $0108,(SP) }
  163.     {$ENDC}
  164.  
  165. FUNCTION MemError : OSErr;
  166.     {$IFC NOT CFMSYSTEMCALLS}
  167.     INLINE $3EB8, $0220;            { MOVE.w $0220,(SP) }
  168.     {$ENDC}
  169.  
  170. FUNCTION GetZone: THz;
  171.     {$IFC NOT GENERATINGCFM}
  172.     INLINE $A11A, $2E88;
  173.     {$ENDC}
  174. FUNCTION NewHandle(byteCount: Size): Handle;
  175.     {$IFC NOT GENERATINGCFM}
  176.     INLINE $201F, $A122, $2E88;
  177.     {$ENDC}
  178. FUNCTION NewHandleSys(byteCount: Size): Handle;
  179.     {$IFC NOT GENERATINGCFM}
  180.     INLINE $201F, $A522, $2E88;
  181.     {$ENDC}
  182. FUNCTION NewHandleClear(byteCount: Size): Handle;
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $201F, $A322, $2E88;
  185.     {$ENDC}
  186. FUNCTION NewHandleSysClear(byteCount: Size): Handle;
  187.     {$IFC NOT GENERATINGCFM}
  188.     INLINE $201F, $A722, $2E88;
  189.     {$ENDC}
  190. FUNCTION HandleZone(h: Handle): THz;
  191.     {$IFC NOT GENERATINGCFM}
  192.     INLINE $205F, $A126, $2E88;
  193.     {$ENDC}
  194. FUNCTION RecoverHandle(p: Ptr): Handle;
  195.     {$IFC NOT GENERATINGCFM}
  196.     INLINE $205F, $A128, $2E88;
  197.     {$ENDC}
  198. FUNCTION RecoverHandleSys(p: Ptr): Handle;
  199.     {$IFC NOT GENERATINGCFM}
  200.     INLINE $205F, $A528, $2E88;
  201.     {$ENDC}
  202. FUNCTION NewPtr(byteCount: Size): Ptr;
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $201F, $A11E, $2E88;
  205.     {$ENDC}
  206. FUNCTION NewPtrSys(byteCount: Size): Ptr;
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $201F, $A51E, $2E88;
  209.     {$ENDC}
  210. FUNCTION NewPtrClear(byteCount: Size): Ptr;
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $201F, $A31E, $2E88;
  213.     {$ENDC}
  214. FUNCTION NewPtrSysClear(byteCount: Size): Ptr;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $201F, $A71E, $2E88;
  217.     {$ENDC}
  218. FUNCTION PtrZone(p: Ptr): THz;
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $205F, $A148, $2E88;
  221.     {$ENDC}
  222. FUNCTION MaxBlock: LONGINT;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $A061, $2E80;
  225.     {$ENDC}
  226. FUNCTION MaxBlockSys: LONGINT;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $A461, $2E80;
  229.     {$ENDC}
  230. FUNCTION StackSpace: LONGINT;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $A065, $2E80;
  233.     {$ENDC}
  234. FUNCTION NewEmptyHandle: Handle;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $A166, $2E88;
  237.     {$ENDC}
  238. FUNCTION NewEmptyHandleSys: Handle;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $A566, $2E88;
  241.     {$ENDC}
  242. PROCEDURE HLock(h: Handle);
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $205F, $A029;
  245.     {$ENDC}
  246. PROCEDURE HUnlock(h: Handle);
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $205F, $A02A;
  249.     {$ENDC}
  250. PROCEDURE HPurge(h: Handle);
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $205F, $A049;
  253.     {$ENDC}
  254. PROCEDURE HNoPurge(h: Handle);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $205F, $A04A;
  257.     {$ENDC}
  258. PROCEDURE HLockHi(h: Handle);
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $205F, $A064, $A029;
  261.     {$ENDC}
  262. FUNCTION TempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $3F3C, $001D, $A88F;
  265.     {$ENDC}
  266. FUNCTION TempMaxMem(VAR grow: Size): Size;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $3F3C, $0015, $A88F;
  269.     {$ENDC}
  270. FUNCTION TempFreeMem: LONGINT;
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $3F3C, $0018, $A88F;
  273.     {$ENDC}
  274. {  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  }
  275. PROCEDURE TempHLock(h: Handle; VAR resultCode: OSErr);
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $3F3C, $001E, $A88F;
  278.     {$ENDC}
  279. PROCEDURE TempHUnlock(h: Handle; VAR resultCode: OSErr);
  280.     {$IFC NOT GENERATINGCFM}
  281.     INLINE $3F3C, $001F, $A88F;
  282.     {$ENDC}
  283. PROCEDURE TempDisposeHandle(h: Handle; VAR resultCode: OSErr);
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $3F3C, $0020, $A88F;
  286.     {$ENDC}
  287. FUNCTION TempTopMem: Ptr;
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $3F3C, $0016, $A88F;
  290.     {$ENDC}
  291. PROCEDURE InitApplZone;
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $A02C;
  294.     {$ENDC}
  295. PROCEDURE InitZone(pgrowZone: GrowZoneUPP; cmoreMasters: INTEGER; limitPtr: UNIV Ptr; startPtr: UNIV Ptr);
  296. PROCEDURE SetZone(hz: THz);
  297.     {$IFC NOT GENERATINGCFM}
  298.     INLINE $205F, $A01B;
  299.     {$ENDC}
  300. FUNCTION CompactMem(cbNeeded: Size): Size;
  301.     {$IFC NOT GENERATINGCFM}
  302.     INLINE $201F, $A04C, $2E80;
  303.     {$ENDC}
  304. FUNCTION CompactMemSys(cbNeeded: Size): Size;
  305.     {$IFC NOT GENERATINGCFM}
  306.     INLINE $201F, $A44C, $2E80;
  307.     {$ENDC}
  308. PROCEDURE PurgeMem(cbNeeded: Size);
  309.     {$IFC NOT GENERATINGCFM}
  310.     INLINE $201F, $A04D;
  311.     {$ENDC}
  312. PROCEDURE PurgeMemSys(cbNeeded: Size);
  313.     {$IFC NOT GENERATINGCFM}
  314.     INLINE $201F, $A44D;
  315.     {$ENDC}
  316. FUNCTION FreeMem: LONGINT;
  317.     {$IFC NOT GENERATINGCFM}
  318.     INLINE $A01C, $2E80;
  319.     {$ENDC}
  320. FUNCTION FreeMemSys: LONGINT;
  321.     {$IFC NOT GENERATINGCFM}
  322.     INLINE $A41C, $2E80;
  323.     {$ENDC}
  324. PROCEDURE ReserveMem(cbNeeded: Size);
  325.     {$IFC NOT GENERATINGCFM}
  326.     INLINE $201F, $A040;
  327.     {$ENDC}
  328. PROCEDURE ReserveMemSys(cbNeeded: Size);
  329.     {$IFC NOT GENERATINGCFM}
  330.     INLINE $201F, $A440;
  331.     {$ENDC}
  332. FUNCTION MaxMem(VAR grow: Size): Size;
  333.     {$IFC NOT GENERATINGCFM}
  334.     INLINE $225F, $A11D, $2288, $2E80;
  335.     {$ENDC}
  336. FUNCTION MaxMemSys(VAR grow: Size): Size;
  337.     {$IFC NOT GENERATINGCFM}
  338.     INLINE $225F, $A51D, $2288, $2E80;
  339.     {$ENDC}
  340. PROCEDURE SetGrowZone(growZone: GrowZoneUPP);
  341.     {$IFC NOT GENERATINGCFM}
  342.     INLINE $205F, $A04B;
  343.     {$ENDC}
  344. PROCEDURE SetApplLimit(zoneLimit: UNIV Ptr);
  345.     {$IFC NOT GENERATINGCFM}
  346.     INLINE $205F, $A02D;
  347.     {$ENDC}
  348. PROCEDURE MoveHHi(h: Handle);
  349.     {$IFC NOT GENERATINGCFM}
  350.     INLINE $205F, $A064;
  351.     {$ENDC}
  352. PROCEDURE DisposePtr(p: Ptr);
  353.     {$IFC NOT GENERATINGCFM}
  354.     INLINE $205F, $A01F;
  355.     {$ENDC}
  356. FUNCTION GetPtrSize(p: Ptr): Size;
  357. PROCEDURE SetPtrSize(p: Ptr; newSize: Size);
  358.     {$IFC NOT GENERATINGCFM}
  359.     INLINE $201F, $205F, $A020;
  360.     {$ENDC}
  361. PROCEDURE DisposeHandle(h: Handle);
  362.     {$IFC NOT GENERATINGCFM}
  363.     INLINE $205F, $A023;
  364.     {$ENDC}
  365. PROCEDURE SetHandleSize(h: Handle; newSize: Size);
  366.     {$IFC NOT GENERATINGCFM}
  367.     INLINE $201F, $205F, $A024;
  368.     {$ENDC}
  369. FUNCTION GetHandleSize(h: Handle): Size;
  370. FUNCTION InlineGetHandleSize(h: Handle): Size;
  371.     {$IFC NOT GENERATINGCFM}
  372.     INLINE $205F, $A025, $2E80;
  373.     {$ENDC}
  374. PROCEDURE ReallocateHandle(h: Handle; byteCount: Size);
  375.     {$IFC NOT GENERATINGCFM}
  376.     INLINE $201F, $205F, $A027;
  377.     {$ENDC}
  378. PROCEDURE EmptyHandle(h: Handle);
  379.     {$IFC NOT GENERATINGCFM}
  380.     INLINE $205F, $A02B;
  381.     {$ENDC}
  382. PROCEDURE HSetRBit(h: Handle);
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $205F, $A067;
  385.     {$ENDC}
  386. PROCEDURE HClrRBit(h: Handle);
  387.     {$IFC NOT GENERATINGCFM}
  388.     INLINE $205F, $A068;
  389.     {$ENDC}
  390. PROCEDURE MoreMasters;
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $A036;
  393.     {$ENDC}
  394. PROCEDURE BlockMove(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  395.     {$IFC NOT GENERATINGCFM}
  396.     INLINE $201F, $225F, $205F, $A02E;
  397.     {$ENDC}
  398. PROCEDURE BlockMoveData(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $201F, $225F, $205F, $A22E;
  401.     {$ENDC}
  402. PROCEDURE PurgeSpace(VAR total: LONGINT; VAR contig: LONGINT);
  403. FUNCTION HGetState(h: Handle): SInt8;
  404.     {$IFC NOT GENERATINGCFM}
  405.     INLINE $205F, $A069, $1E80;
  406.     {$ENDC}
  407. PROCEDURE HSetState(h: Handle; flags: ByteParameter);
  408.     {$IFC NOT GENERATINGCFM}
  409.     INLINE $101F, $205F, $A06A;
  410.     {$ENDC}
  411. PROCEDURE SetApplBase(startPtr: UNIV Ptr);
  412.     {$IFC NOT GENERATINGCFM}
  413.     INLINE $205F, $A057;
  414.     {$ENDC}
  415. PROCEDURE MaxApplZone;
  416.     {$IFC NOT GENERATINGCFM}
  417.     INLINE $A063;
  418.     {$ENDC}
  419. FUNCTION HoldMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  420.     {$IFC NOT GENERATINGCFM}
  421.     INLINE $225F, $205F, $7000, $A05C, $3E80;
  422.     {$ENDC}
  423. FUNCTION UnholdMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  424.     {$IFC NOT GENERATINGCFM}
  425.     INLINE $225F, $205F, $7001, $A05C, $3E80;
  426.     {$ENDC}
  427. FUNCTION LockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  428.     {$IFC NOT GENERATINGCFM}
  429.     INLINE $225F, $205F, $7002, $A05C, $3E80;
  430.     {$ENDC}
  431. FUNCTION LockMemoryContiguous(address: UNIV Ptr; count: LONGINT): OSErr;
  432.     {$IFC NOT GENERATINGCFM}
  433.     INLINE $225F, $205F, $7004, $A05C, $3E80;
  434.     {$ENDC}
  435. FUNCTION UnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  436.     {$IFC NOT GENERATINGCFM}
  437.     INLINE $225F, $205F, $7003, $A05C, $3E80;
  438.     {$ENDC}
  439. FUNCTION GetPhysical(VAR addresses: LogicalToPhysicalTable; VAR physicalEntryCount: LONGINT): OSErr;
  440. FUNCTION DeferUserFn(userFunction: UserFnUPP; argument: UNIV Ptr): OSErr;
  441.     {$IFC NOT GENERATINGCFM}
  442.     INLINE $201F, $205F, $A08F, $3E80;
  443.     {$ENDC}
  444. FUNCTION DebuggerGetMax: LONGINT;
  445.     {$IFC NOT GENERATINGCFM}
  446.     INLINE $7000, $A08D, $2E80;
  447.     {$ENDC}
  448. PROCEDURE DebuggerEnter;
  449.     {$IFC NOT GENERATINGCFM}
  450.     INLINE $7001, $A08D;
  451.     {$ENDC}
  452. PROCEDURE DebuggerExit;
  453.     {$IFC NOT GENERATINGCFM}
  454.     INLINE $7002, $A08D;
  455.     {$ENDC}
  456. PROCEDURE DebuggerPoll;
  457.     {$IFC NOT GENERATINGCFM}
  458.     INLINE $7003, $A08D;
  459.     {$ENDC}
  460. FUNCTION GetPageState(address: UNIV Ptr): PageState;
  461.     {$IFC NOT GENERATINGCFM}
  462.     INLINE $205F, $7004, $A08D, $3E80;
  463.     {$ENDC}
  464. FUNCTION PageFaultFatal: BOOLEAN;
  465.     {$IFC NOT GENERATINGCFM}
  466.     INLINE $7005, $A08D, $1E80;
  467.     {$ENDC}
  468. FUNCTION DebuggerLockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  469.     {$IFC NOT GENERATINGCFM}
  470.     INLINE $225F, $205F, $7006, $A08D, $3E80;
  471.     {$ENDC}
  472. FUNCTION DebuggerUnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  473.     {$IFC NOT GENERATINGCFM}
  474.     INLINE $225F, $205F, $7007, $A08D, $3E80;
  475.     {$ENDC}
  476. FUNCTION EnterSupervisorMode: StatusRegisterContents;
  477.     {$IFC NOT GENERATINGCFM}
  478.     INLINE $7008, $A08D, $3E80;
  479.     {$ENDC}
  480. { StripAddress and Translate24To32 macro to nothing on PowerPC
  481.    StripAddress is implemented as a trap in System 6 or later }
  482. {$IFC SystemSixOrLater }
  483. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  484.     {$IFC NOT GENERATINGCFM}
  485.     INLINE $201F, $A055, $2E80;
  486.     {$ENDC}
  487. {$ELSEC}
  488. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  489. {$ENDC}
  490. FUNCTION Translate24To32(addr24: UNIV Ptr): Ptr;
  491.     {$IFC NOT GENERATINGCFM}
  492.     INLINE $201F, $A091, $2E80;
  493.     {$ENDC}
  494. FUNCTION HandToHand(VAR theHndl: Handle): OSErr;
  495. FUNCTION PtrToXHand(srcPtr: UNIV Ptr; dstHndl: Handle; size: LONGINT): OSErr;
  496.     {$IFC NOT GENERATINGCFM}
  497.     INLINE $201F, $225F, $205F, $A9E2, $3E80;
  498.     {$ENDC}
  499. FUNCTION PtrToHand(srcPtr: UNIV Ptr; VAR dstHndl: Handle; size: LONGINT): OSErr;
  500. FUNCTION HandAndHand(hand1: Handle; hand2: Handle): OSErr;
  501.     {$IFC NOT GENERATINGCFM}
  502.     INLINE $225F, $205F, $A9E4, $3E80;
  503.     {$ENDC}
  504. FUNCTION PtrAndHand(ptr1: UNIV Ptr; hand2: Handle; size: LONGINT): OSErr;
  505.     {$IFC NOT GENERATINGCFM}
  506.     INLINE $201F, $225F, $205F, $A9EF, $3E80;
  507.     {$ENDC}
  508. {$IFC OLDROUTINENAMES }
  509. FUNCTION ApplicZone: THz;
  510.     {$IFC NOT GENERATINGCFM}
  511.     INLINE $2EB8, $02AA;
  512.     {$ENDC}
  513. FUNCTION MFTempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  514.     {$IFC NOT GENERATINGCFM}
  515.     INLINE $3F3C, $001D, $A88F;
  516.     {$ENDC}
  517. FUNCTION MFMaxMem(VAR grow: Size): Size;
  518.     {$IFC NOT GENERATINGCFM}
  519.     INLINE $3F3C, $0015, $A88F;
  520.     {$ENDC}
  521. FUNCTION MFFreeMem: LONGINT;
  522.     {$IFC NOT GENERATINGCFM}
  523.     INLINE $3F3C, $0018, $A88F;
  524.     {$ENDC}
  525. PROCEDURE MFTempHLock(h: Handle; VAR resultCode: OSErr);
  526.     {$IFC NOT GENERATINGCFM}
  527.     INLINE $3F3C, $001E, $A88F;
  528.     {$ENDC}
  529. PROCEDURE MFTempHUnlock(h: Handle; VAR resultCode: OSErr);
  530.     {$IFC NOT GENERATINGCFM}
  531.     INLINE $3F3C, $001F, $A88F;
  532.     {$ENDC}
  533. PROCEDURE MFTempDisposHandle(h: Handle; VAR resultCode: OSErr);
  534.     {$IFC NOT GENERATINGCFM}
  535.     INLINE $3F3C, $0020, $A88F;
  536.     {$ENDC}
  537. FUNCTION MFTopMem: Ptr;
  538.     {$IFC NOT GENERATINGCFM}
  539.     INLINE $3F3C, $0016, $A88F;
  540.     {$ENDC}
  541. PROCEDURE ResrvMem(cbNeeded: Size);
  542.     {$IFC NOT GENERATINGCFM}
  543.     INLINE $201F, $A040;
  544.     {$ENDC}
  545. PROCEDURE DisposPtr(p: Ptr);
  546.     {$IFC NOT GENERATINGCFM}
  547.     INLINE $205F, $A01F;
  548.     {$ENDC}
  549. PROCEDURE DisposHandle(h: Handle);
  550.     {$IFC NOT GENERATINGCFM}
  551.     INLINE $205F, $A023;
  552.     {$ENDC}
  553. PROCEDURE ReallocHandle(h: Handle; byteCount: Size);
  554.     {$IFC NOT GENERATINGCFM}
  555.     INLINE $201F, $205F, $A027;
  556.     {$ENDC}
  557. {$ENDC}
  558.  
  559. { $ALIGN RESET}
  560. { $POP}
  561.  
  562. {$ENDC} {__MEMORY__}
  563.  
  564.  IMPLEMENTATION
  565.  END.
  566.  
  567.